{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "71e6d8fe-84c4-47d7-8fd7-f6a66fed72e1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# imports \n",
    "import os\n",
    "import json\n",
    "import operator\n",
    "import pandas as pd\n",
    "from io import StringIO\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import random\n",
    "\n",
    "# settings\n",
    "BotHash = \"BEEB1E1549DDD01226DC2FC912ABAE49\"\n",
    "BotName = \"PokerShark2\"\n",
    "SB = 10\n",
    "\n",
    "# players\n",
    "Players = ['PokerShark1']\n",
    "\n",
    "# helper functions\n",
    "def prettyPrint(*arguments):\n",
    "    out = ''\n",
    "    for arg in arguments:\n",
    "        space = (30-len(arg)) * \" \"\n",
    "        out += arg + space\n",
    "    print(out)\n",
    "\n",
    "# gets an array of paths to player games\n",
    "def getGamesPath(playerName):\n",
    "    return [os.path.join(playerName,f) for f in os.listdir(playerName) if not f.startswith('.')]\n",
    "\n",
    "# Load game as json object.\n",
    "def loadGame(path):\n",
    "    with open(path) as f:\n",
    "        g = json.load(f)\n",
    "        # Throw if game not logged by the current version of the bot\n",
    "        if g[\"BotHash\"] != BotHash:\n",
    "            #raise Exception(\"BotHash does not match: \" + g[\"BotHash\"])\n",
    "            pass\n",
    "        return g\n",
    "\n",
    "# game statistics\n",
    "def getGamesCount(playerName):\n",
    "    # returns number of games played against the given player.\n",
    "    return len(getGamesPath(playerName))\n",
    "\n",
    "def getGameResultForPlayer(game, playerName):\n",
    "    # returns game result for given player.\n",
    "    results = game[\"Results\"]\n",
    "    maxStack = 0\n",
    "    hasMax = []\n",
    "    # find max stack\n",
    "    for result in results:\n",
    "        if maxStack < result[\"Stack\"]:\n",
    "            maxStack = result[\"Stack\"]\n",
    "            hasMax= [result[\"Player\"][\"Name\"]]\n",
    "        elif maxStack == result[\"Stack\"]:\n",
    "            hasMax.append(result[\"Player\"][\"Name\"])\n",
    "    # find player result\n",
    "    if playerName in hasMax:\n",
    "        if len(hasMax) > 1:\n",
    "            return 'D'\n",
    "        else:\n",
    "            return 'W'\n",
    "    return 'L'\n",
    "\n",
    "def getWonGamesCount(playerName):\n",
    "    # returns number of games won against the given player.\n",
    "    count = 0\n",
    "    files = getGamesPath(playerName)\n",
    "    for file in files:\n",
    "        game = loadGame(file)\n",
    "        result = getGameResultForPlayer(game, BotName)\n",
    "        if result == 'W':\n",
    "            count += 1\n",
    "    return count\n",
    "\n",
    "def getDrewGamesCount(playerName):\n",
    "    # return number of games drew against the given player.\n",
    "    count = 0\n",
    "    files = getGamesPath(playerName)\n",
    "    for file in files:\n",
    "        game = loadGame(file)\n",
    "        result = getGameResultForPlayer(game, BotName)\n",
    "        if result == 'D':\n",
    "            count += 1\n",
    "    return count\n",
    "\n",
    "def getLostGamesCount(playerName):\n",
    "    # return number of games lost against the given player.\n",
    "    count = 0\n",
    "    files = getGamesPath(playerName)\n",
    "    for file in files:\n",
    "        game = loadGame(file)\n",
    "        result = getGameResultForPlayer(game, BotName)\n",
    "        if result == 'L':\n",
    "            count += 1\n",
    "    return count\n",
    "\n",
    "def getEndStack(playerName):\n",
    "    # return sum of the stack after the games.\n",
    "    s = 0\n",
    "    files = getGamesPath(playerName)\n",
    "    for file in files:\n",
    "        game = loadGame(file)\n",
    "        for result in game[\"Results\"]:\n",
    "            if result[\"Player\"][\"Name\"] == BotName:\n",
    "                s += result[\"Stack\"]\n",
    "    return s\n",
    "            \n",
    "# round statistics\n",
    "def getRoundsCount(playerName):\n",
    "    # returns number of rounds played against the given player.\n",
    "    count = 0\n",
    "    files = getGamesPath(playerName)\n",
    "    for file in files:\n",
    "        game = loadGame(file)\n",
    "        count += len(game[\"Rounds\"])\n",
    "    return count\n",
    "\n",
    "def GetRoundResultForPlayer(r, playerName):\n",
    "    results = r[\"Winner\"]\n",
    "    winners = len(results)\n",
    "    won = False\n",
    "    for result in results:\n",
    "        if playerName == result[\"Name\"]:\n",
    "            won = True\n",
    "            break\n",
    "    if won:\n",
    "        if winners > 1:\n",
    "            return 'D'\n",
    "        else:\n",
    "            return 'W'\n",
    "    return 'L'\n",
    "\n",
    "def getWonRoundsCount(playerName):\n",
    "    # returns number of rounds won against the given player.\n",
    "    count = 0\n",
    "    files = getGamesPath(playerName)\n",
    "    for file in files:\n",
    "        game = loadGame(file)\n",
    "        for r in game[\"Rounds\"]:\n",
    "            result = GetRoundResultForPlayer(r, BotName)\n",
    "            if result == 'W':\n",
    "                count += 1\n",
    "    return count\n",
    "\n",
    "def getDrewRoundsCount(playerName):\n",
    "    # return number of games rounds against the given player.\n",
    "    count = 0\n",
    "    files = getGamesPath(playerName)\n",
    "    for file in files:\n",
    "        game = loadGame(file)\n",
    "        for r in game[\"Rounds\"]:\n",
    "            result = GetRoundResultForPlayer(r, BotName)\n",
    "            if result == 'D':\n",
    "                count += 1\n",
    "    return count\n",
    "\n",
    "def getLostRoundsCount(playerName):\n",
    "    # return number of rounds lost against the given player.\n",
    "    count = 0\n",
    "    files = getGamesPath(playerName)\n",
    "    for file in files:\n",
    "        game = loadGame(file)\n",
    "        for r in game[\"Rounds\"]:\n",
    "            result = GetRoundResultForPlayer(r, BotName)\n",
    "            if result == 'L':\n",
    "                count += 1\n",
    "    return count\n",
    "\n",
    "def endedBeforeShowdown(r):\n",
    "    # returns true if one of the two players folded.\n",
    "    for action in r[\"History\"]:\n",
    "        if action[\"Type\"] == \"Fold\":\n",
    "            return True\n",
    "    return False\n",
    "\n",
    "def botFolded(r):\n",
    "    # returns true if one of the two players folded.\n",
    "    for action in r[\"History\"]:\n",
    "        if action[\"Type\"] == \"Fold\" and action[\"PlayerName\"] == BotName:\n",
    "            return True\n",
    "    return False\n",
    "\n",
    "def getPaid(r,playerName):\n",
    "    # returns amount paid by player\n",
    "    amount = 0\n",
    "    # blinds\n",
    "    sbp = r['SmallBlindPosition']\n",
    "    for p in range(len(r['Players'])):\n",
    "        if r['Players'][p]['Name'] == playerName:\n",
    "            if p == sbp:\n",
    "                amount += SB\n",
    "            else:\n",
    "                amount += SB + SB\n",
    "    # calls and raises\n",
    "    for action in r[\"History\"]:\n",
    "        if action[\"Type\"] != \"Fold\" and action[\"PlayerName\"] == playerName:\n",
    "            amount += action[\"Amount\"]\n",
    "    return amount\n",
    "\n",
    "# winning statistics\n",
    "def getNonShowdownWinningsLine(playerName):\n",
    "    # line goes down each time bot fold, and up each time your opponent fold.\n",
    "    x = [0]\n",
    "    y = [0]\n",
    "    line = 0\n",
    "    count = 1\n",
    "    files = getGamesPath(playerName)\n",
    "    for file in files:\n",
    "        game = loadGame(file)\n",
    "        for r in game[\"Rounds\"]:\n",
    "            if endedBeforeShowdown(r):\n",
    "                if botFolded(r):\n",
    "                    line -= getPaid(r,BotName)\n",
    "                else:\n",
    "                    line += getPaid(r,playerName)\n",
    "            x.append(count)\n",
    "            y.append(line)\n",
    "            count += 1\n",
    "    return (x,y)\n",
    "\n",
    "def getShowdownWinningsLine(playerName):\n",
    "    # line goes down each time bot fold, and up each time your opponent fold.\n",
    "    x = [0]\n",
    "    y = [0]\n",
    "    line = 0\n",
    "    count = 1\n",
    "    files = getGamesPath(playerName)\n",
    "    for file in files:\n",
    "        game = loadGame(file)\n",
    "        for r in game[\"Rounds\"]:\n",
    "            if not endedBeforeShowdown(r):\n",
    "                # if bot won\n",
    "                if GetRoundResultForPlayer(r, BotName) == 'W':\n",
    "                    line += getPaid(r,playerName)\n",
    "                if GetRoundResultForPlayer(r, BotName) == 'L':\n",
    "                    line -= getPaid(r,BotName)\n",
    "                \n",
    "            x.append(count)\n",
    "            y.append(line)\n",
    "            count += 1\n",
    "    return (x,y)\n",
    "\n",
    "def getStackLine(playerName):\n",
    "    # line goes down each time bot fold, and up each time your opponent fold.\n",
    "    x = [0]\n",
    "    y = [0]\n",
    "    line = 0\n",
    "    count = 1\n",
    "    files = getGamesPath(playerName)\n",
    "    for file in files:\n",
    "        game = loadGame(file)\n",
    "        for r in game[\"Rounds\"]:\n",
    "            if GetRoundResultForPlayer(r, BotName) == 'W':\n",
    "                line += getPaid(r,playerName)\n",
    "            if GetRoundResultForPlayer(r, BotName) == 'L':\n",
    "                line -= getPaid(r,BotName)\n",
    "            x.append(count)\n",
    "            y.append(line)\n",
    "            count += 1\n",
    "    return (x,y)\n",
    "\n",
    "def plotWinnings(playerName):\n",
    "    # NonShowdownWinningsLine\n",
    "    x,y = getNonShowdownWinningsLine(playerName)\n",
    "    fig, ax = plt.subplots()\n",
    "    xpoints = np.array(x)\n",
    "    ypoints = np.array(y)\n",
    "    ax.plot(xpoints, ypoints,linewidth=1,label='Non-showdown winnings', c='r')\n",
    "    # ShowdownWinningsLine\n",
    "    x,y = getShowdownWinningsLine(playerName)\n",
    "    xpoints = np.array(x)\n",
    "    ypoints = np.array(y)\n",
    "    ax.plot(xpoints, ypoints,linewidth=1,label='Showdown winnings', c='b')\n",
    "    # Stack\n",
    "    x,y = getStackLine(playerName)\n",
    "    xpoints = np.array(x)\n",
    "    ypoints = np.array(y)\n",
    "    ax.plot(xpoints, ypoints,linewidth=1,label='Winnings', c='g')\n",
    "    # show plot\n",
    "    y_max = np.abs(ax.get_ylim()).max()\n",
    "    ax.set_ylim(ymin=-y_max, ymax=y_max)\n",
    "    ax.set_xlim(left=0)\n",
    "    plt.legend()\n",
    "    plt.grid(linestyle = '--', linewidth = 0.5)\n",
    "    plt.show()\n",
    "    \n",
    "    \n",
    "# Print Results\n",
    "def PrintResult():\n",
    "    for player in Players:\n",
    "        prettyPrint(\"Results against:\", player)\n",
    "        # game statistics\n",
    "        n = getGamesCount(player)\n",
    "        w = getWonGamesCount(player)\n",
    "        d = getDrewGamesCount(player)\n",
    "        l = getLostGamesCount(player)\n",
    "        prettyPrint(\"number of games:\",str(n))\n",
    "        prettyPrint(\"number of games won:\", str(w) , \"{:.1f}\".format(w*100/n) + \"%\")\n",
    "        prettyPrint(\"number of games drew:\", str(d), \"{:.1f}\".format(d*100/n) + \"%\")\n",
    "        prettyPrint(\"number of games lost:\", str(l), \"{:.1f}\".format(l*100/n) + \"%\")\n",
    "        # round statistics\n",
    "        rn = getRoundsCount(player)\n",
    "        rw = getWonRoundsCount(player)\n",
    "        rd = getDrewRoundsCount(player)\n",
    "        rl = getLostRoundsCount(player)\n",
    "        prettyPrint(\"number of rounds:\",str(rn))\n",
    "        prettyPrint(\"number of rounds won:\", str(rw) , \"{:.1f}\".format(rw*100/rn) + \"%\")\n",
    "        prettyPrint(\"number of rounds drew:\", str(rd), \"{:.1f}\".format(rd*100/rn) + \"%\")\n",
    "        prettyPrint(\"number of rounds lost:\", str(rl), \"{:.1f}\".format(rl*100/rn) + \"%\")\n",
    "        # winnings\n",
    "        prettyPrint(\"starting stack:\", str(1000 * n))\n",
    "        prettyPrint(\"end stack:\", str(getEndStack(player)))\n",
    "        prettyPrint(\"win/loss:\", str(getEndStack(player) - (1000 * n)  ))\n",
    "        prettyPrint(\"WPH:\", str((getEndStack(player) - (1000 * n)) / (rn*10)))\n",
    "        plotWinnings(player)\n",
    "        # end\n",
    "        print('-------------------------------------------------------------')\n",
    "        \n",
    "      "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "f45a61bb-8373-4bd1-8fd6-b85a124517bd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dynamic player:\n",
      "Results against:              PokerShark2                   \n",
      "number of games:              100                           \n",
      "number of games won:          53                            53.0%                         \n",
      "number of games drew:         2                             2.0%                          \n",
      "number of games lost:         45                            45.0%                         \n",
      "number of rounds:             10000                         \n",
      "number of rounds won:         5064                          50.6%                         \n",
      "number of rounds drew:        4                             0.0%                          \n",
      "number of rounds lost:        4932                          49.3%                         \n",
      "starting stack:               100000                        \n",
      "end stack:                    102260.0                      \n",
      "win/loss:                     2260.0                        \n",
      "WPH:                          0.0226                        \n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-------------------------------------------------------------\n",
      "risk-neutral player:\n",
      "Results against:              PokerShark1                   \n",
      "number of games:              100                           \n",
      "number of games won:          45                            45.0%                         \n",
      "number of games drew:         2                             2.0%                          \n",
      "number of games lost:         53                            53.0%                         \n",
      "number of rounds:             10000                         \n",
      "number of rounds won:         4932                          49.3%                         \n",
      "number of rounds drew:        4                             0.0%                          \n",
      "number of rounds lost:        5064                          50.6%                         \n",
      "starting stack:               100000                        \n",
      "end stack:                    97740.0                       \n",
      "win/loss:                     -2260.0                       \n",
      "WPH:                          -0.0226                       \n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-------------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "\n",
    "dynamic = \"PokerShark1\"\n",
    "neutral = \"PokerShark2\"\n",
    "\n",
    "# print Dynamic stats\n",
    "print(\"Dynamic player:\")\n",
    "BotName = dynamic\n",
    "os.rename(\"games\", neutral)\n",
    "Players = [neutral]\n",
    "PrintResult()\n",
    "\n",
    "# print Risk neutral stats\n",
    "print(\"risk-neutral player:\")\n",
    "BotName = neutral\n",
    "os.rename(neutral, dynamic)\n",
    "Players = [dynamic]\n",
    "PrintResult()\n",
    "os.rename(dynamic, \"games\")\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ecb3052c-f407-4cc7-a654-f4b4264b1b01",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
